home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.3d26 source / tn3270 / grafterm.c < prev    next >
C/C++ Source or Header  |  1991-06-03  |  61KB  |  2,449 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.3d21, January 17, 1991
  5.  *  Copyright (c) 1988, 1989, 1990, 1991 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #include "maclib.h"
  34. #include "termdef.h"
  35. #include "globals.h"
  36. #include "telnet.h"
  37.  
  38. #define adMin         39
  39. #define adMax         37
  40.  
  41. /* location for disk initialization dialog */
  42. #define kDITop        0x0050
  43. #define kDILeft        0x0070
  44.  
  45. #define gestaltPPCSupportsRealTime    0x1000
  46.  
  47. extern char vmxbgn, vmxsub, kabort;
  48. extern char xdlg;
  49. extern DialogPtr xdlgptr;
  50. extern Rect gr_rect;
  51. extern short vnum;
  52. extern char hisopts[];
  53. extern vmprt prtinfo;
  54. extern char skipnewmode;
  55. extern Handle rcvMessage;            /* PPC message buffers */
  56. extern Handle sndMessage;
  57.  
  58. struct Point sfppoint, sfgpoint;    /* standard file dialog locations */
  59. char da_menu = 0;                    /* TRUE when DA menu should be displayed */
  60. char showstg = 0;                    /* True when storage info. wanted */
  61. int button;                            /* button down at startup */
  62. char tcpinitok = 0;                    /* tcp network stuff active */
  63. char pend_conn = 0;                    /* pending connection state (TCP/IP) */
  64. short systemvol;                    /* volume with system files */
  65. int defaultv;                        /* default volume for TCP/IP FTP */
  66.  
  67. Rect statRect, textRect, scrnRect, pictRect;
  68. Rect cposRect;                        /* rectangle for cursor postion numbers */
  69. GDHandle bitmap_gdev;                /* gdev used for bitmaps */
  70. GDHandle saved_gdev;                /* gdev for set/rest gdev */
  71.  
  72. unsigned char ordertab[256];        /* table checking for 3270 order vs. data */
  73. unsigned char nlbuff[80];            /* buffer for language translation */
  74.                                     /* size = screen width */
  75. Handle alaxtabh;                    /* handle to ALA diacritic table */
  76.  
  77. short hpixsize, vpixsize, scrvoff, scrhsize, scrhoff;
  78. short htxtstrt, vtxtstrt, vtxtsize, htxtsize, curvsize, curhsize;
  79. short curnum, x_origin, y_origin;
  80. short maxcnt, maxoff;
  81. long textsize, pictsize;    /* size in bytes for stginfo */
  82. short launchvol;            /* default volume at launch */
  83. char newserver;                /* Telnet server supports new protocol */
  84. char statcpos;                /* only draw curor position in status line */
  85. char smallscreen;            /* complete 24 x 80 window doesn't fit */
  86. char pendalign;                /* alignbitmap call pending */
  87. char serverconn = 0;        /* connecting to non-terminal server*/
  88. char servermode = 0;        /* server connection active */
  89. char serverflags = 0;        /* flags bits for special server processing */
  90. char notifyavail = 0;        /* Notification Manager available */
  91. nmrmessage *myNMR[NMRNUM];    /* pointers to Notification Manager messages */
  92.  
  93. PaletteHandle myPalette;
  94. short pxsize;
  95. RGBColor realblack = {0, 0, 0};
  96. RGBColor realwhite = {0xffff, 0xffff, 0xffff};
  97.  
  98. Ptr myNewPtr();
  99.  
  100. main()
  101. {
  102. short rc;
  103. char dummy[28];
  104. short rid;
  105. ResType rtype;
  106. Rect deskrect;
  107. unsigned short height, width;
  108. Handle temph;
  109. short i;
  110.  
  111. int_active = wr_active = 0;
  112. aplmode = insmode = online = 0; /* init. status line */
  113. drawpict = 0;
  114. newpict = 1;
  115. savepict = 0;            /* not saving graphics in PICT file */
  116. textsel = 0;            /* no text selected */
  117. pndinv = pndclr = pndnewmode = 0;
  118. needwrite = 0;
  119. kb_err = 0;
  120. kbqsize = 0;
  121. ioerror = 0;
  122. logon = 0;
  123. kblock = 1;
  124. kblcode = 4;
  125. ftpcopen = ftpdopen = ftplopen = 0;        /* no TCP/IP FTP yet */
  126. kb_handle = 0;            /* no keyboard mapping yet */
  127. nl_handle = 0;            /* no language mapping yet */
  128. stdfont = NORMALFONT;    /* use normal 3278 font */
  129. plainala = 0;            /* overstrike with ALA */
  130. sndhandle = 0;            /* default (system) sound */
  131. sndactive = 0;            /* no sound currently active */
  132. prtinit = 0;
  133. myWindow = 0;            /* no window yet */
  134. atrbuff = 0;            /* no attribute buffer */
  135. readbuff = 0;            /* no read-modified response buffer */
  136. chrbuff = 0;            /* no 3270 screen buffer */
  137. scrapstart = 0;            /* no private scrap storage */
  138. mapptr = pmapptr = 0;    /* no bitmaps yet */
  139. textmap = 0;            /* no text bitmap yet */
  140. x = y = 0;                /* initial cursor position */
  141. newserver = 0;            /* default 0; only set by TCP code */
  142. statcpos = 0;            /* draw cursor position only */
  143. smallscreen = 0;        /* assume window will fit */
  144. pendalign = 0;            /* alignbitmap call not pending */
  145. skipnewmode = 0;        /* call newmode for EW/EWA as usual */
  146. wposok = 0;                /* window position not set yet */
  147. smgr_sppc = sess_sppc = 0;    /* no SPPC registrations yet */
  148. smgrppc = sessppc = 0;    /* no PPC ports yet */
  149. rcvMessage = sndMessage = 0;    /* no ppc buffers yet */
  150. GetVol(ordertab, &launchvol);    /* define launchvol */
  151. apiopen = 0;            /* apiopenreq not in use */
  152. apiclosenotify = 0;        /* no close notification */
  153.  
  154.                         /* define handle to EBCDIC to ASCII table */
  155. xtabh = GetResource('GFXT', 128);
  156. alaxtabh = GetResource('GFXT', 129);
  157.                         /* define prtinfo */
  158. temph = GetResource('VMPR', 128);
  159. if (temph != 0) {
  160.     movmem(*temph, &prtinfo, sizeof(vmprt));
  161.     if (prtinfo.linewidth > MAXLINEWIDTH) prtinfo.linewidth = MAXLINEWIDTH;
  162.     if (prtinfo.titlewidth > MAXLINEWIDTH) prtinfo.titlewidth = MAXLINEWIDTH;
  163.     }
  164.     
  165. orderinit();            /* initialize ordertab */
  166.  
  167. macinit();                /* general Mac initialization */
  168. hnd_init();                /* handle any update events */
  169.  
  170.                         /* calculate limits for screen format */
  171. getdeskrect(&deskrect);
  172. height = deskrect.bottom;
  173. height -= deskrect.top;
  174. height -= 47;
  175.         /* If the top of the desk rectangle is <= 0, it includes the
  176.            menu bar, and the size of the menu bar is subtracted */
  177. if (deskrect.top <= 0) {
  178.     height -= 20;
  179.     }
  180. width = deskrect.right;
  181. width -= deskrect.left;
  182. width -= 13;
  183.  
  184.     /* calculate 9 and 12-point limits */
  185. rowmax9 = height/12;
  186. if (rowmax9 < 24) {
  187.     rowmax9 = 24;
  188.     smallscreen = 1;
  189.     }
  190. colmax9 = width/6;
  191. if (colmax9 < 80) {
  192.     colmax9 = 80;
  193.     }
  194. rowmax12 = height/16;
  195. colmax12 = width/7;
  196.  
  197. rc = init_settings();    /* get initial settings */
  198.  
  199.                         /* set keymap handle if not already set */
  200. if (kb_handle == 0L) {
  201.     kb_handle = GetNamedResource('GFKB', cskybdname);
  202.     if (kb_handle == 0L) {
  203.         stoperr(kbdefalrt);
  204.         ExitToShell();
  205.         }
  206.     else {
  207.         GetResInfo(kb_handle, &rid, &rtype, fskybdname);
  208.         strcpy(cskybdname, fskybdname);
  209.         }
  210.     }
  211.                     /* initialize for connection type */
  212. if (serflg) {            /* serial */
  213.     ser_init();
  214.     }
  215. else if (tcpflg) {        /* tcpip */
  216.     tcp_init();
  217.     if (ioerror != 0) {
  218.         macend();
  219.         return;
  220.         }
  221.     }
  222. else {                    /* AppleTalk */
  223.     net_init();
  224.     }
  225.  
  226. if (rc != 0) {            /* set default host if no settings file */
  227.     if (serflg) serdflthost(cshostname);
  228.     else if (tcpflg) tcpdflthost(cshostname);
  229.     else netdflthost(cshostname);
  230.     strcpy(fshostname, cshostname);
  231.     }
  232.  
  233. GetVol(dummy, &vnum);    /* init. default volume for file transfer */
  234. defaultv = vnum;        /* also set for FTP */
  235. xfinit();
  236.                 /* login if net connection, settings file, and autoconn */
  237. if ((!serflg) && (rc == 0) && cs.autoconn) {
  238.     if (tcpflg) tcplgin();
  239.     else netlgin();
  240.     }
  241.  
  242. done = false;
  243. while (!done) hndmac();        /* handle Mac events and I/O */
  244.  
  245. if (serflg) ser_end();        /* clean-up I/O */
  246. else if (tcpflg) tcp_end();
  247.      else net_end();
  248. macend();                    /* clean-up Mac */
  249. }
  250.  
  251. macinit()
  252. {
  253. short i;
  254. static char * ScrDmpEnb = (char *)0x2f8;
  255. pascal void attnmenu();
  256. static void (*attnhdl) ();
  257. SysEnvRec theWorld;
  258. GDHandle currGD;
  259. PixMapHandle currPM;
  260. char *s;
  261. Rect deskrect;
  262. OSErr rc;
  263.  
  264.             /* set-up general Macintosh environment */
  265. MaxApplZone();                /* set-up for efficient storage use */
  266. for (i=0; i < 4; i++) MoreMasters();
  267. InitGraf(&qd.thePort);
  268. FlushEvents(everyEvent, 0);
  269. InitWindows();
  270. InitFonts();
  271. InitMenus();
  272. InitDialogs(0L);
  273. InitCursor();
  274. TEInit();
  275.  
  276.             /* set-up menus */
  277. for (i=0; i < NMENUS; i++) {
  278.     myMenus[i] = GetMenu(256+i);
  279.     if (i == 4) {        /* attn key menu */
  280.         attnhdl = attnmenu;
  281.         (*myMenus[4])->menuProc = (Handle)&attnhdl;
  282.         CalcMenuSize(myMenus[4]);
  283.         (*myMenus[4])->enableFlags = 1;
  284.         }
  285.     if (i < 5) InsertMenu(myMenus[i], 0);
  286.         /* 5th menu inserted by tcp_init */
  287.     }
  288. AddResMenu(myMenus[0], 'DRVR');
  289.  
  290. kybdMenu = GetMenu(235);
  291. InsertMenu(kybdMenu, -1);
  292. AddResMenu(kybdMenu, 'GFKB');
  293.  
  294. nlMenu = GetMenu(234);
  295. InsertMenu(nlMenu, -1);
  296. AddResMenu(nlMenu, 'GFNL');
  297.  
  298. /* define csnlname from the name of the first item in the */
  299. /* national language menu */
  300. GetItem(nlMenu, 1, csnlname);
  301.  
  302. appl_menu();
  303. DrawMenuBar();
  304.  
  305.             /* check if mouse is down at startup */
  306. button = Button(); 
  307.  
  308.             /* get environment information */
  309. SysEnvirons(1, &theWorld);        
  310. newroms = (theWorld.machineType >= 0);
  311. colormac = (theWorld.hasColorQD != 0);
  312. systemvol = theWorld.sysVRefNum;
  313. syslevel = theWorld.systemVersion >> 8;
  314. notifyavail = (syslevel >= 6);
  315.  
  316. if (colormac) {        /* We have color QuickDraw, now check if        */
  317.                     /* the deepest display device supports color.    */
  318.                     /* We won't use color if the device is            */
  319.                     /* monochrome and the current pixel size        */
  320.                     /* is 1.  Ideally, we would be able to            */
  321.                     /* decide based on the maximum pixel size.        */
  322.     getdeskrect(&deskrect);
  323.     currGD = GetMaxDevice(&deskrect);
  324.     currPM = (*currGD)->gdPMap;
  325.     if ((*currPM)->pixelSize == 1) 
  326.         colormac = (*currGD)->gdFlags & (1 << gdDevType);
  327.     }
  328.  
  329. /* determine if Gestalt is available */
  330. gestaltavail = 0;
  331. if (newroms) {       /* compare Gestalt OS trap to Unimplemented Toolbox trap */
  332.     gestaltavail = NGetTrapAddress(0xAD, 0) !=
  333.                    NGetTrapAddress(0x9F, 1);
  334.     }
  335.  
  336. /* determine availability of PPC */
  337. ppcavail = 0;
  338. ppcflags = 0;
  339. if (gestaltavail) {
  340.     rc = Gestalt('ppc ', &ppcflags);
  341.     ppcavail = (rc == noErr);
  342.     if (!ppcavail) ppcflags = 0;
  343.     }
  344.  
  345. screenRect = qd.screenBits.bounds;
  346.  
  347.             /* read alerts into memory and center */
  348. ctralrt(263);
  349. ctralrt(264);
  350. ctralrt(265);
  351. ctralrt(274);
  352. ctralrt(275);
  353. ctralrt(276);
  354. ctralrt(278);
  355. ctralrt(279);
  356. ctralrt(281);
  357.  
  358.             /* calculate standard file dialog location*/
  359. sfppoint.h = (screenRect.right-screenRect.left-304)/2;
  360. sfgpoint.h = (screenRect.right-screenRect.left-348)/2;
  361. if (smallscreen) {
  362.     sfppoint.v = (screenRect.bottom-screenRect.top-184)/2;
  363.     sfgpoint.v = (screenRect.bottom-screenRect.top-200)/2;
  364.     }
  365. else {
  366.     sfppoint.v = (screenRect.bottom-screenRect.top-184)/3;
  367.     sfgpoint.v = (screenRect.bottom-screenRect.top-200)/3;
  368.     }
  369.  
  370. if (colormac) {
  371.     getdeskrect(&dragRect);
  372.     }
  373. else {
  374.     SetRect(&dragRect, 0, 24, screenRect.right-4, screenRect.bottom-4);
  375.     }
  376.  
  377.             /* allocate storage for "fs" string variables and api
  378.                variables :
  379.                fshostname = 128
  380.                fskybdname = 256
  381.                fsnlname = 256
  382.                fssndname = 256
  383.                apihostname = 256
  384.                apiwindowname = 128  total = 1280 bytes */
  385.  
  386.  
  387. s = NewPtr((Size)1280);
  388. if (s == 0L) {
  389.     stgalert("fs_and_api_variables", "NewPtr", (Size)1280);
  390.     ExitToShell();
  391.     }
  392. fshostname = s;
  393. fskybdname = s + 128;
  394. fsnlname = s + 384;
  395. fssndname = s + 640;
  396. apihostname = s + 896;
  397. apiwindowname = s + 1152;
  398.  
  399.             /* allocate storage for notification manager */
  400. for (i=0; i < NMRNUM; i++) {
  401.     myNMR[i] = (nmrmessage *)NewPtr((long)(sizeof(nmrmessage)));
  402.     if (myNMR[i] == 0L) {
  403.         notifyavail = 0;
  404.         stgalert("nmrmessages", "NewPtr", (long)(sizeof(nmrmessage)));
  405.         ExitToShell();
  406.         }
  407.     else {
  408.         memset(myNMR[i], 0, sizeof(nmrmessage));        
  409.         }
  410.     }
  411.  
  412.             /* allocate sound channel storage (about 1K) */
  413. scp = (SndChannelPtr)NewPtr((long)(sizeof(struct SndChannel)));
  414. if (scp == 0L) {
  415.     stgalert("sound channel", "NewPtr", (long)(sizeof(struct SndChannel)));
  416.     ExitToShell();
  417.     }
  418. setmem(scp, sizeof(struct SndChannel), 0);
  419. scp->qLength = stdQLength;
  420.  
  421.  
  422.             /* allocate print record */
  423. hPrint = (THPrint)NewHandle((long)sizeof(struct TPrint));
  424. if (hPrint == 0L) {
  425.     stgalert("print record", "NewHandle", (long)(sizeof(struct TPrint)));
  426.     ExitToShell();
  427.     }
  428.  
  429.             /* allocate work regions for grow icon */
  430. cliprgn = NewRgn();    
  431. destrgn = NewRgn();
  432. temprgn = NewRgn();
  433. if ((cliprgn == 0L) || (destrgn == 0L) || (temprgn == 0L)) {
  434.     stgalert("grow icon regions", "NewRgn", 0L);
  435.     ExitToShell();
  436.     }
  437.     
  438.             /* miscellaneous initialization */
  439. CouldDialog(256);
  440. ScrDmpSav = *ScrDmpEnb;        /* save current byte */
  441. sw_bgrnd = 0;                /* not in switcher background */
  442. mf_bgrnd = 0;                /* not in MultiFinder background */
  443.  
  444. /* if PPC is available, initialize it */
  445. if (ppcavail) {
  446.     if ((ppcflags & gestaltPPCSupportsRealTime) == 0) {
  447.         rc = PPCInit();
  448.         if (rc == noErr) {
  449.             rc = Gestalt('ppc ', &ppcflags);
  450.             }
  451.         if (rc != noErr) {
  452.             ppcavail = 0;
  453.             ppcflags = 0;
  454.             stoperr(ppcinitalrt);
  455.             }
  456.         }
  457.     }
  458.  
  459. /* if ppc will be used, initialize queues */
  460. if (ppcavail) {
  461.     initparamblocks();
  462.     initclientrecs();
  463.     initdatablocks();
  464.     addparamblocks();
  465.     addclientrecs();
  466.     adddatablocks();
  467.     }
  468.  
  469. apiregister(0);        /* attempt to register session mgr with sppc and ppc */
  470.  
  471. }
  472.  
  473. hnd_init()                /* handle update events during intialization */
  474. {
  475. short evtrc;
  476.  
  477. evtrc = GetNextEvent(updateMask, &myEvent);
  478. while (evtrc != 0) {
  479.     switch(myEvent.what) {
  480.         case updateEvt:
  481.                                 updevent(myEvent.message);
  482.                                 break;
  483.         default:
  484.                                 break;
  485.         }
  486.     evtrc = GetNextEvent(updateMask, &myEvent);
  487.     }
  488. }
  489.  
  490. /*    createwindow is called to create a new window when there is no
  491.     current session (and no window).  At this point, the user's requested
  492.     screen size will be used for the new window, and to determine the
  493.     size of our private scrap. */
  494.  
  495. OSErr createwindow()
  496. {
  497. OSErr rc, newmode();
  498. Size allocsize;
  499.  
  500.                         /* set variables for this session */
  501. if (apiopen) {
  502.     ses_altrows = apiopenreq.altsize.rows;
  503.     ses_altcols = apiopenreq.altsize.cols;
  504.     ses_altptsize = apiopenreq.altsize.ptsize;
  505.     ses_dfltptsize = apiopenreq.dfltsize.ptsize;
  506.     }
  507. else {
  508.     ses_altrows = cs.altrows;
  509.     ses_altcols = cs.altcols;
  510.     ses_altptsize = cs.altptsize;
  511.     ses_dfltptsize = cs.dfltptsize;
  512.     }
  513. ses_windmax = cs.windmax;
  514. addr14 = (ses_altrows * ses_altcols) > 4096;
  515.  
  516.                         /* allocate scrap of proper size */
  517. rc = newscrap();
  518. if (rc != noErr) {
  519.     stoperr(newwindalrt);
  520.     return(rc);
  521.     }
  522. /* In following code, no need to clean up scrap, since scrap persists,
  523.    in order to not lose its contents needlessly.  (Newscrap will keep the
  524.    existing scrap if it has the proper line width for this session.)    */
  525.  
  526.                         /* allocate 3270 screen buffers */
  527.                             /* 3270 attribute buffer */
  528. allocsize = ses_altrows * ses_altcols;
  529. allocsize <<= 1;
  530. atrbuff = (short *)myNewPtr(allocsize);
  531. if (atrbuff == 0L) {
  532.     stoperr(newwindalrt);
  533.     return(2);
  534.     }
  535. setmem(atrbuff, (short)allocsize, 0);
  536.                             /* buffer for read responses */
  537.     /* size based on vmxfer maximum response: 
  538.        6 byte prefix
  539.        2 bytes: DB
  540.        4608 bytes: 2304 bytes of data with IAC quoting
  541.        5 bytes: CRC suffix
  542.        2 bytes: IAC, EOR
  543.        1 byte padding
  544.        ==> 4624 bytes        */
  545.  
  546. readbuff = (unsigned char *)myNewPtr((long)4624L);    
  547. if (readbuff == 0L) {
  548.     DisposPtr(atrbuff);
  549.     stoperr(newwindalrt);
  550.     return(3);
  551.     }
  552. setmem(readbuff, 4624, 0);
  553. rballoc = 4101;        /* limits responses to 4K (first 5 bytes not included) */
  554.  
  555.                             /* 3270 screen image buffer */
  556. allocsize = ses_altrows * ses_altcols;
  557. chrbuff = (unsigned char *)myNewPtr(allocsize);
  558. if (chrbuff == 0L) {
  559.     DisposPtr(readbuff);
  560.     DisposPtr(atrbuff);
  561.     stoperr(newwindalrt);
  562.     return(4);
  563.     }
  564. setmem(chrbuff, (short)allocsize, 0);
  565.                         /* create new window with alt. size */
  566. ewamode = 1;
  567. rc = newmode(1, 1);
  568. if (rc != noErr) {
  569.     DisposPtr(chrbuff);
  570.     DisposPtr(readbuff);
  571.     DisposPtr(atrbuff);
  572.     stoperr(newwindalrt);
  573.     return(rc);
  574.     }
  575. clrscn();
  576. invldscr();
  577. return(noErr);
  578. }
  579.  
  580. removewindow()            /* completely remove window and buffers */
  581. {                        /* (returning to state with no window active) */
  582. removemywindow();        
  583. DisposPtr(chrbuff);
  584. DisposPtr(readbuff);
  585. DisposPtr(atrbuff);
  586. }
  587.                 
  588. removemywindow()        /* remove window in preparation for new mode */
  589. {
  590. updwindpos();
  591. removebitmaps();
  592. if (colormac) {
  593.     restorectab();
  594.     }
  595. CloseWindow(myWindow);
  596. myWindow = 0;
  597. arrowcursor();
  598. }
  599.  
  600. removebitmaps()
  601. {
  602. if (colormac) {
  603.     if (WritePtr != myWindow) rmPix(WritePtr, mapptr);
  604.     if (PictPtr != 0) rmPix(PictPtr, pmapptr);
  605.     }
  606. else {
  607.     if (WritePtr != myWindow) ClosePort(WritePtr);
  608.     if (mapptr != 0) DisposPtr(mapptr);
  609.     if (PictPtr != 0) ClosePort(PictPtr);
  610.     if (pmapptr != 0) DisposPtr(pmapptr);
  611.     }
  612. PictPtr = 0;
  613. textmap = 0;
  614. mapptr = pmapptr = 0;
  615. textsize = pictsize = 0;
  616. }
  617.  
  618. restorectab()
  619. {
  620. static unsigned char * RomMapInsert = (unsigned char *)0xb9e;
  621. static unsigned char * TmpResLoad = (unsigned char *)0xb9f;
  622. PaletteHandle oldpalette, fixpalette;
  623. short pixdepth, colorcnt;
  624. GDHandle currGD;
  625. PixMapHandle currPM;
  626. CTabHandle dflttab;
  627.  
  628.                     /* attempt to restore default color table */
  629. if (!colormac) return;        /* done if no color */
  630. if (myWindow == 0) return;    /* return if no window */
  631. if (syslevel > 6) return;    /* return if system handles color without our help */
  632.  
  633. currGD = GetGDevice();        /* get pixel depth */
  634. currPM = (*currGD)->gdPMap;
  635. pixdepth = (*currPM)->pixelSize;
  636.  
  637. colorcnt = 2 << (pixdepth-1);        /* compute number of colors */
  638.  
  639.                             /* get default color table for pixel depth */
  640. (*RomMapInsert) = 0xff;            /* include ROM in search */
  641. (*TmpResLoad) = 0;                /* shouldn't need to load into memory */
  642. dflttab = (CTabHandle)GetResource('clut', pixdepth);
  643. if (dflttab == 0) return;        /* give up if no resource */
  644.  
  645.                             /* use palette to set colors */
  646. fixpalette = NewPalette(colorcnt+1, dflttab, pmTolerant, 0);
  647. if (fixpalette == 0) return;            /* give up if can't get a palette */
  648. oldpalette = GetPalette(myWindow);
  649. SetPalette(myWindow, fixpalette, 0);    /* use new palette */
  650. ActivatePalette(myWindow);
  651. if (oldpalette != 0) {
  652.     DisposePalette(oldpalette);            /* free previous palette */
  653.     }
  654. }
  655.  
  656. OSErr newmode(mode, create)
  657. char mode;            /* 0 = normal; 1 = alternate */
  658. char create;        /* 0 = change size; 1 = create window */
  659. {            
  660. short wproc;
  661. BitMap PictMap;
  662. BitMap WriteMap;
  663. Size mapsize, pmapsize;
  664. Ptr temp;
  665. WStateData * wsptr;
  666. short i, logrows, logcols;
  667. short old_hpix, old_vpix;
  668. Point p, q;
  669. Rect r;
  670. RGBColor rgbtemp;
  671. PixMapHandle currPM;
  672. short adj;
  673. char cposstr[16];
  674. OSErr alignbitmaps();
  675. Boolean wvis;
  676.  
  677. /* calculate buffer size variables (logical rows and columns) */
  678. if (mode == 0) {
  679.     logrows = 24;
  680.     logcols = 80;
  681.     }
  682. else {
  683.     logrows = ses_altrows;
  684.     logcols = ses_altcols;
  685.     }
  686.  
  687. /* update the 3270 buffer variables */
  688. maxcnt = logrows * logcols;
  689. maxoff = maxcnt - 1;
  690. scrvoff = logrows - 1;
  691. scrhsize = logcols;
  692. scrhoff = scrhsize - 1;
  693. if (curadr > maxoff) curadr = maxoff;    /* keep cursor within text area */
  694.  
  695. /* handle AppleTalk call at interrupt level */
  696. if (int_active) {
  697.     pndmode = mode;
  698.     pndnewmode = 1;
  699.     return;
  700.     }
  701. else {
  702.     pndnewmode = 0;
  703.     }
  704.  
  705. /* calculate window size variables */
  706. cur_mode = mode;
  707. if (cur_mode == 1) {
  708.     cur_rows = ses_altrows;
  709.     cur_cols = ses_altcols;
  710.     cur_ptsize = ses_altptsize;
  711.     }
  712. else {
  713.     cur_rows = 24;
  714.     cur_cols = 80;
  715.     cur_ptsize = ses_dfltptsize;
  716.     }
  717.     
  718.                             /* save current window dimensions */
  719. old_hpix = hpixsize;
  720. old_vpix = vpixsize;
  721.                             /* set constants for new screen */
  722. setmode(cur_rows, cur_cols, cur_ptsize, ses_windmax);
  723.  
  724. /* return if the current window is already the proper size */
  725. if (myWindow != 0) {
  726.     if ((old_hpix == hpixsize) && (old_vpix == vpixsize)) {
  727.         return(0);
  728.         }
  729.     }
  730.  
  731. if (myWindow != 0) {                /* clean-up old window and bitmaps */
  732.     if (create) removemywindow();    /* keep 3270 buffers */
  733.     else removebitmaps();
  734.     }
  735.  
  736.                             /* keep cursor on screen */
  737. if (curadr > maxoff) curadr = maxoff;
  738.  
  739.                             /* change cursor if white needed */
  740. if ((!cs.invertbw) && colormac) curnum += 2;
  741.  
  742. defcursor(0,0);                /* define er rectangle for screen cursor */
  743.  
  744.                             /* define window rectangle */
  745. if (smallscreen) {
  746.     pRect.top = (screenRect.bottom-screenRect.top-vpixsize)/2 + 9;
  747.     }
  748. else {
  749.     pRect.top = (screenRect.bottom-screenRect.top-vpixsize)/2 + 19;
  750.     }
  751. if ((pRect.top < 38) && (!smallscreen)) {
  752.     pRect.top = 38;
  753.     }
  754. pRect.left = (screenRect.right-screenRect.left-hpixsize)/2 - 1;
  755. if (pRect.left < 1) {
  756.     pRect.left = 1;
  757.     }
  758. pRect.bottom = pRect.top+vpixsize;
  759. pRect.right = pRect.left+hpixsize;
  760.  
  761. sizeRect.top = 25;
  762. sizeRect.left = 50;
  763. sizeRect.bottom = pRect.bottom - pRect.top + 1;
  764. sizeRect.right = pRect.right - pRect.left + 1;
  765.  
  766. wproc = documentProc + 8;
  767.  
  768. if (myWindow == 0) {
  769.     r = pRect;
  770.     if (wposok) {    /* use stored window position if available */
  771.         p.h = cs.windpth;
  772.         p.v = cs.windptv;
  773.         r.left = p.h - hpixsize/2 - 1;
  774.         r.right = r.left + hpixsize + 3;
  775.         r.top = p.v - vpixsize/2 - 10;
  776.         r.bottom = r.top + vpixsize + 21;
  777.         adjmove(&r);
  778.         r.left += 1;            /* window rectangle -> port rectangle */
  779.         r.right -= 2;
  780.         r.top += 19;
  781.         r.bottom -= 2;
  782.         }
  783.     if (colormac) {
  784.         if (apiopen) {
  785.             wvis = true;
  786.             if (apiopenreq.hide != 0) wvis = false;
  787.             myWindow = NewCWindow(&wRecord, &r, apiwindowname,
  788.                         wvis, wproc, -1L, true, 0L);
  789.             }
  790.         else {
  791.             myWindow = NewCWindow(&wRecord, &r, wtitle,
  792.                         true, wproc, -1L, true, 0L);
  793.             }
  794.         if (myWindow == 0L) {
  795.             return(5);
  796.             }
  797.         myPalette = NewPalette(11, 0L, pmCourteous, 0);
  798.         if (myPalette == 0L) {
  799.             CloseWindow(myWindow);
  800.             return(6);
  801.             }
  802.         SetPalette(myWindow, myPalette, true);
  803.         fixcolors(myPalette);        /* define colors to use */
  804.         ActivatePalette(myWindow);
  805.         }
  806.     else {
  807.         if (apiopen) {
  808.             wvis = true;
  809.             if (apiopenreq.hide != 0) wvis = false;
  810.             myWindow = NewWindow(&wRecord, &r, apiwindowname,
  811.                         wvis, wproc, -1L, true, 0L);
  812.             }
  813.         else {
  814.             myWindow = NewWindow(&wRecord, &r, wtitle,
  815.                         true, wproc, -1L, true, 0L);
  816.             }
  817.         if (myWindow == 0L) {
  818.             return(7);
  819.             }
  820.         }
  821.     }
  822. else {
  823.     SetPort(myWindow);
  824.     /* change window size, and keep center of window constant */
  825.     q.h = myWindow->portRect.left;    /* save old top left of portRect */
  826.     q.v = myWindow->portRect.top;
  827.     LocalToGlobal(&q);
  828.     p.h = (myWindow->portRect.right + myWindow->portRect.left + 1)/2;
  829.     p.v = (myWindow->portRect.bottom + myWindow->portRect.top - 17)/2;
  830.     LocalToGlobal(&p);        /* global current center */
  831.     r.left = p.h - hpixsize/2 - 1;
  832.     r.right = r.left + hpixsize + 3;
  833.     r.top = p.v - vpixsize/2 - 10;
  834.     r.bottom = r.top + vpixsize + 21;
  835.     adjmove(&r);
  836.     r.left += 1;            /* window rectangle -> port rectangle */
  837.     r.right -= 2;
  838.     r.top += 19;
  839.     r.bottom -= 2;
  840.     p.h = r.left;
  841.     p.v = r.top;
  842.     if (((p.h - q.h) < 0) || ((p.v - q.v) < 0)) {    /* small -> large */
  843.         MoveWindow(myWindow, p.h, p.v, true);
  844.         SizeWindow(myWindow, hpixsize, vpixsize, true);
  845.         }
  846.     else {                            /* large -> small */
  847.         SizeWindow(myWindow, hpixsize, vpixsize, true);
  848.         MoveWindow(myWindow, p.h, p.v, true);
  849.         }
  850.     InvalRect(&gr_rect);
  851.     InitClip();
  852.     InvalRect(&gr_rect);
  853.  
  854.     /* restore settings before bitmap allocation */
  855.     if (colormac) {
  856.         RGBBackColor(&realwhite);
  857.         ActivatePalette(myWindow);
  858.         }
  859.     }
  860.  
  861. if (((WindowPeek)myWindow)->dataHandle != 0) {
  862.     wsptr = (struct WStateData *)(*(((WindowPeek)myWindow)->dataHandle));
  863.     wsptr->stdState = pRect;
  864.     if (r == pRect) {
  865.         adj = (pRect.bottom - pRect.top) / 4;
  866.         wsptr->userState.top = pRect.top + adj;
  867.         wsptr->userState.bottom = pRect.bottom - adj;
  868.         adj = (pRect.right - pRect.left) / 4;
  869.         wsptr->userState.left = pRect.left + adj;
  870.         wsptr->userState.right = pRect.right - adj;
  871.         }
  872.     else {
  873.         wsptr->userState = r;
  874.         }
  875.     zoomok = 1;
  876.     }
  877. else zoomok = 0;
  878.  
  879. SetPort(myWindow);
  880. TextFont(stdfont);
  881. TextSize(cur_ptsize);
  882. x_origin = -4;
  883. y_origin = -6;
  884. SetOrigin(x_origin, y_origin);
  885. InitClip();
  886. grafcursor = GetCursor(curnum);
  887. InitCursor();
  888. dfltcurs = 1;    
  889.  
  890.             /* if color available, save pixel size for this window */
  891. if (colormac) {
  892.     GetGlobalRect(myWindow, &r);
  893.     bitmap_gdev = GetMaxDevice(&r);
  894.     currPM = (*bitmap_gdev)->gdPMap;
  895.     pxsize = (*currPM)->pixelSize;
  896.     }
  897.  
  898. textRect.top = scrnRect.top = y_origin;
  899. statRect.left = textRect.left = scrnRect.left = x_origin;
  900. statRect.top = textRect.bottom = y_origin + vpixsize - 19;
  901. statRect.bottom = scrnRect.bottom = statRect.top + 20;
  902. statRect.right = textRect.right = scrnRect.right = textRect.left + hpixsize;
  903.  
  904.                 /* attempt to allocate text bitmap */
  905. WriteMap.bounds.top = 0;
  906. WriteMap.bounds.left = 0;
  907. WriteMap.bounds.bottom = vpixsize;
  908. WriteMap.bounds.right = hpixsize;
  909. if (colormac) {
  910.     mkPix(&WritePort, &mapptr, &(WriteMap.bounds), 0, bitmap_gdev);
  911.     textsize = pictsize;
  912.     pictsize = 0;
  913.     if (mapptr == 0) {
  914.         WritePtr = myWindow;
  915.         note_err(mapalrt);
  916.         }
  917.     else {
  918.         WritePtr = &WritePort;
  919.         textmap = 1;
  920.         }
  921.     SetPort(WritePtr);
  922.     GetEntryColor(myPalette, RGBback, &rgbtemp);
  923.     if (WritePtr != myWindow) setgdev();
  924.     RGBBackColor(&rgbtemp);
  925.     if (WritePtr != myWindow) resetgdev();
  926.     }
  927. else {
  928.     WriteMap.rowBytes = (((hpixsize + 31) >> 5) + 1) << 2;
  929.     mapsize = WriteMap.bounds.bottom - WriteMap.bounds.top;
  930.     mapsize = mapsize * WriteMap.rowBytes + 4;
  931.     textsize = mapsize;
  932.     mapptr = myNewPtr(mapsize);
  933.     temp = mapptr;
  934.     while (((Size)temp%4) != 0) temp++;    /* align on long word */
  935.     WriteMap.baseAddr = temp;
  936.     if (WriteMap.baseAddr == 0L) {        /* no screen buffer */
  937.         WritePtr = myWindow;
  938.         note_err(mapalrt);
  939.         }
  940.     else {
  941.         WritePtr = &WritePort;            /* set-up WritePort */
  942.         textmap = 1;
  943.         WritePort.portRect = WriteMap.bounds;
  944.         OpenPort(WritePtr);
  945.         ClipRect(&WritePort.portRect);
  946.         SetPortBits(&WriteMap);
  947.         EraseRgn(WritePort.visRgn);
  948.         TextFont(stdfont);
  949.         TextSize(cur_ptsize);
  950.         }
  951.     }
  952. if (WritePtr != myWindow) {
  953.     SetPort(WritePtr);
  954.      SetOrigin(textRect.left, textRect.top);
  955.     ClipRect(&scrnRect);
  956.     SetPort(myWindow);
  957.     }
  958.                                  /* set-up graphics bit map */
  959. pictRect.top = pictRect.left = 0;
  960. pictRect.bottom = vpixsize-19;
  961. pictRect.right = hpixsize;
  962.  
  963. PictPtr = &PictPort;
  964. if (!colormac) {
  965.     PictMap.rowBytes = (((hpixsize + 31) >> 5) + 1) << 2;
  966.     PictMap.bounds = pictRect;
  967.     pmapsize = PictMap.bounds.bottom - PictMap.bounds.top;
  968.     pmapsize = pmapsize * PictMap.rowBytes + 4;
  969.     pictsize = pmapsize;
  970.     pmapptr = myNewPtr(pmapsize);
  971.     temp = pmapptr;
  972.     while (((Size)temp%4) != 0) temp++;    /* align on long word */
  973.     PictMap.baseAddr = temp;
  974.     if (PictMap.baseAddr == 0L) {        /* no graphics bitmap */
  975.         PictPtr = 0;
  976.         }
  977.     else {
  978.                                     /* set-up PictPort */
  979.         OpenPort(PictPtr);
  980.         SetPortBits(&PictMap);
  981.         PortSize(PictMap.bounds.right, PictMap.bounds.bottom);
  982.         SetRectRgn(PictPort.visRgn, 0, 0, PictMap.bounds.right,
  983.                     PictMap.bounds.bottom);
  984.         ClipRect(&PictPort.portRect);
  985.         EraseRect(&PictPort.portRect);
  986.         SetOrigin(0, 0);
  987.         TextFont(stdfont);
  988.         TextSize(cur_ptsize);
  989.         }
  990.     }
  991. else {
  992.     mkPix(&PictPort, &pmapptr, &pictRect, 0, bitmap_gdev);
  993.     if (pmapptr == 0) PictPtr = 0;
  994.     else {
  995.         PictPtr = &PictPort;
  996.         GetEntryColor(myPalette, RGBback, &rgbtemp);
  997.         setgdev();
  998.         RGBBackColor(&rgbtemp);
  999.         resetgdev();
  1000.         }
  1001.     }
  1002.  
  1003. /* define status line cursor postion rectangle */
  1004. cposRect.top = statRect.top;
  1005. cposRect.bottom = statRect.bottom;
  1006. cposRect.left = 315;
  1007. sprintf(cposstr, "%02d/%02d", scrvoff+1, scrhsize);
  1008. TextFont(1);
  1009. TextSize(0);
  1010. cposRect.right = cposRect.left + StringWidth(cposstr);
  1011. TextFont(stdfont);
  1012. TextSize(cur_ptsize);
  1013.             /* for small screens, adjust cursor position between insert
  1014.                mode symbol and time */
  1015. adj = 10 - hpixsize + 134 + cposRect.right;
  1016. if (adj > 0) {
  1017.     cposRect.left -= adj;
  1018.     cposRect.right -= adj;
  1019.     }
  1020.  
  1021. alignbitmaps();        /* always safe to call */
  1022. invldscr();
  1023. newstat();
  1024. return(0);
  1025. }
  1026.  
  1027. OSErr alignbitmaps()        
  1028.                     /* Adjust bounds of our bitmaps for long word alignment
  1029.                        with the current window position.  Note that our
  1030.                        CopyBits calls copy the leftmost bit of each bitmap
  1031.                        to the leftmost bit of the window. */
  1032.                     /* Non-zero return code indicates no need to redraw
  1033.                        text bitmap */
  1034. {
  1035. short pixeldepth;
  1036. GDHandle currGD;
  1037. PixMapHandle currPM;
  1038. GrafPtr gp;
  1039. Point p;
  1040. Rect r;
  1041. short adj;
  1042. BitMap * mapbits;
  1043.  
  1044. if (drawpict) {
  1045.     pendalign = 1;
  1046.     return(1);
  1047.     }
  1048. else {
  1049.     pendalign = 0;
  1050.     }
  1051.                         /* nothing to do if no bitmaps */
  1052. if ((!textmap) && (PictPtr == 0)) {
  1053.     return(2);
  1054.     }
  1055.  
  1056. if (colormac) {
  1057.                         /* if pixel depth has changed, return, since
  1058.                            we will be called for the new bitmap        */
  1059.     GetGlobalRect(myWindow, &r);
  1060.     currGD = GetMaxDevice(&r);
  1061.     currPM = (*currGD)->gdPMap;
  1062.     if (pxsize != (*currPM)->pixelSize) return(3);
  1063.     if (pxsize > 16) return(4);        /* no adjustment needed */
  1064.     pixeldepth = pxsize;
  1065.     }
  1066. else {
  1067.     pixeldepth = 1;
  1068.     }
  1069.  
  1070. p.h = textRect.left;
  1071. p.v = textRect.top;
  1072. GetPort(&gp);
  1073. SetPort(myWindow);
  1074. LocalToGlobal(&p);
  1075. SetPort(gp);
  1076. getdeskrect(&r);
  1077. p.h = p.h - r.left;        /* ensure a positive value */
  1078. adj = p.h % (32 / pixeldepth);
  1079. if (PictPtr != 0) {
  1080.     if (colormac) {
  1081.         mapbits = (BitMap *)(*(PixMapHandle)PictPort.portBits.baseAddr);
  1082.         }
  1083.     else {
  1084.         mapbits = &PictPort.portBits;
  1085.         }
  1086.     (mapbits->bounds).left = -adj;
  1087.     }
  1088. if (textmap) {
  1089.     if (colormac) {
  1090.         mapbits = (BitMap *)(*(PixMapHandle)WritePort.portBits.baseAddr);
  1091.         }
  1092.     else {
  1093.         mapbits = &WritePort.portBits;
  1094.         }
  1095.     (mapbits->bounds).left = textRect.left - adj;
  1096.     return(0);
  1097.     }
  1098. else {
  1099.     return(5);
  1100.     }
  1101. }
  1102.  
  1103. setmode(dsprows, dspcols, ptsize, wmax)
  1104. short dsprows, dspcols, ptsize, wmax;
  1105. {
  1106. short dflthsize, dfltvsize, althsize, altvsize;
  1107.                                 /* set constants for desired format */
  1108. switch(ptsize) {
  1109.     case 12:
  1110.                 htxtstrt = 0;
  1111.                 vtxtstrt = 11;
  1112.                 vtxtsize = 16;
  1113.                 htxtsize = 7;
  1114.                 curvsize = 16;
  1115.                 curhsize = 7;
  1116.                 curnum = 20846;
  1117.                 break;
  1118.     default:
  1119.                 htxtstrt = 1;
  1120.                 vtxtstrt = 9;
  1121.                 vtxtsize = 12;
  1122.                 htxtsize = 6;
  1123.                 curvsize = 12;
  1124.                 curhsize = 7;
  1125.                 curnum = 20845;
  1126.                 break;
  1127.     }
  1128. if (wmax) {
  1129.     if (ses_dfltptsize == 9) {
  1130.         dflthsize = 80 * 6 + 10;
  1131.         dfltvsize = 24 * 12 + 26;
  1132.         }
  1133.     else {
  1134.         dflthsize = 80 * 7 + 10;
  1135.         dfltvsize = 24 * 16 + 26;
  1136.         }
  1137.     if (ses_altptsize == 9) {
  1138.         althsize = ses_altcols * 6 + 10;
  1139.         altvsize = ses_altrows * 12 + 26;
  1140.         }
  1141.     else {
  1142.         althsize = ses_altcols * 7 + 10;
  1143.         altvsize = ses_altrows * 16 + 26;
  1144.         }
  1145.     if (dflthsize > althsize) {
  1146.         hpixsize = dflthsize;
  1147.         }
  1148.     else {
  1149.         hpixsize = althsize;
  1150.         }
  1151.     if (dfltvsize > altvsize) {
  1152.         vpixsize = dfltvsize;
  1153.         }
  1154.     else {
  1155.         vpixsize = altvsize;
  1156.         }
  1157.     }
  1158. else {
  1159.     hpixsize = dspcols * htxtsize + 10;
  1160.     vpixsize = dsprows * vtxtsize + 26;
  1161.     }
  1162. }
  1163.  
  1164. newdepth()
  1165. {            
  1166.             /* re-allocate bitmaps for new pixel depth */
  1167.             /* (Macs with color QuickDraw only)        */
  1168. PixMapHandle currPM;
  1169. Rect r;
  1170. BitMap WriteMap;
  1171. RGBColor rgbtemp;
  1172. GrafPtr gp;
  1173. OSErr alignbitmaps();
  1174.  
  1175. GetPort(&gp);
  1176.  
  1177. /* clean-up current bitmaps */
  1178. if (WritePtr != myWindow) rmPix(WritePtr, mapptr);
  1179. if (PictPtr != 0) rmPix(PictPtr, pmapptr);
  1180. mapptr = pmapptr = 0;
  1181. textmap = 0;
  1182.  
  1183. /* save new pixel size */
  1184. GetGlobalRect(myWindow, &r);
  1185. bitmap_gdev = GetMaxDevice(&r);
  1186. currPM = (*bitmap_gdev)->gdPMap;
  1187. pxsize = (*currPM)->pixelSize;
  1188.  
  1189. /* restore settings before bitmap allocation */
  1190. SetPort(myWindow);
  1191. RGBBackColor(&realwhite);
  1192.  
  1193. /* Get color table updated for colors we want */
  1194. ActivatePalette(myWindow);
  1195.  
  1196.                 /* attempt to allocate text bitmap */
  1197. WriteMap.bounds.top = 0;
  1198. WriteMap.bounds.left = 0;
  1199. WriteMap.bounds.bottom = vpixsize;
  1200. WriteMap.bounds.right = hpixsize;
  1201. mkPix(&WritePort, &mapptr, &(WriteMap.bounds), 0, bitmap_gdev);
  1202. textsize = pictsize;
  1203. pictsize = 0;
  1204. if (mapptr == 0) {
  1205.     WritePtr = myWindow;
  1206.     note_err(mapalrt);
  1207.     }
  1208. else {
  1209.     WritePtr = &WritePort;
  1210.     textmap = 1;
  1211.     }
  1212. SetPort(WritePtr);
  1213. GetEntryColor(myPalette, RGBback, &rgbtemp);
  1214. if (WritePtr != myWindow) {
  1215.     setgdev();
  1216.     RGBBackColor(&rgbtemp);
  1217.     resetgdev();
  1218.      SetOrigin(textRect.left, textRect.top);
  1219.     ClipRect(&scrnRect);
  1220.     }
  1221. else RGBBackColor(&rgbtemp);
  1222.                                  /* set-up graphics bit map */
  1223. pictRect.top = pictRect.left = 0;
  1224. pictRect.bottom = vpixsize-19;
  1225. pictRect.right = hpixsize;
  1226.  
  1227. PictPtr = &PictPort;
  1228.                                 /* set-up PictPort */
  1229. mkPix(&PictPort, &pmapptr, &pictRect, 0, bitmap_gdev);
  1230. if (pmapptr == 0) PictPtr = 0;
  1231. else {
  1232.     setgdev();
  1233.     PictPtr = &PictPort;
  1234.     GetEntryColor(myPalette, RGBback, &rgbtemp);
  1235.     RGBBackColor(&rgbtemp);
  1236.     resetgdev();
  1237.     }
  1238.  
  1239. SetPort(gp);
  1240. alignbitmaps();
  1241. invldscr();
  1242. newstat();
  1243. justGrowIcon(0);
  1244. }
  1245.  
  1246. macend()
  1247. {
  1248. static char * ScrDmpEnb = (char *)0x2f8;
  1249. scrapline * sp, * nextsp;
  1250.  
  1251.  
  1252. if (myWindow != 0) removewindow();
  1253.  
  1254. if (new_settings()) if (savedlg()) write_settings();
  1255.  
  1256. (*ScrDmpEnb) = ScrDmpSav;    /* restore original byte */
  1257.  
  1258.                             /* clean-up printing */
  1259. if (prtinit) PrClose();
  1260. if (hPrint != 0) DisposHandle(hPrint);
  1261.  
  1262.                             /* clean-up scrap */
  1263. removescrap();
  1264.  
  1265.                             /* clean-up async sound */
  1266. if (sndactive) {
  1267.     SndDisposeChannel(scp, true);
  1268.     }
  1269. if (scp != 0) {
  1270.     DisposPtr(scp);
  1271.     }
  1272. if (sndhandle != 0) {
  1273.     DisposHandle(sndhandle);
  1274.     }
  1275.                             /* clean-up API */
  1276. apideregister(0);
  1277.  
  1278. if (ppcavail) {
  1279.     endparamblocks();
  1280.     endclientrecs();
  1281.     enddatablocks();
  1282.     }
  1283. if (rcvMessage != 0) DisposHandle(rcvMessage);
  1284. if (sndMessage != 0) DisposHandle(sndMessage);
  1285. }                        
  1286.  
  1287. hndmac()
  1288. {
  1289.     register short code;
  1290.     register unsigned short i, w, h;
  1291.     register long l;
  1292.     static unsigned long * Ticks = (unsigned long *)0x16a;
  1293.     static unsigned long * DoubleTime = (unsigned long *)0x2f0;
  1294.     static unsigned long clklimit = 0;
  1295.     static unsigned long limit = 0;
  1296.     unsigned long downticks;
  1297.     GrafPtr gp;
  1298.     Point pt;
  1299.     OSErr rc, alignbitmaps();
  1300.     char background, usenull;
  1301.     unsigned char asciicode, c, selflag; 
  1302.     unsigned char shiftflag, optionflag, commandflag, doubleflag;
  1303.     static short downloc = 0;
  1304.     static short uploc = 0;
  1305.     static short oldloc = 0;
  1306.     short moveloc, newloc;
  1307.     static unsigned long downtime = 0;
  1308.     static unsigned long uptime = 0;
  1309.     unsigned short j, k, hexcount;
  1310.     Size s;
  1311.     hexmap * hm;
  1312.     Point dipoint;
  1313.  
  1314.                                 /* I/O which must happen often */
  1315.     if (serflg) {
  1316.         hndser();
  1317.         serkbd();
  1318.         }
  1319.     else if (netconn) getreq();
  1320.     else if (tcpflg) tcpevent();
  1321.     
  1322.     if (sndactive == 2) {
  1323.         SndDisposeChannel(scp, true);
  1324.         sndactive = 0;
  1325.         }
  1326.     
  1327.                                 /* during FTP, take all we can get */
  1328.     background = mf_bgrnd && !(ftpcopen || ftpdopen || ftplopen);
  1329.  
  1330.     usenull = 1;                /* initially will do null processing */
  1331.                                 
  1332.     if (!background) {            /* don't do non-essential things too often */
  1333.                                 /* when running in the foreground */
  1334.         if (limit >= (*Ticks)) usenull = 0;
  1335.         else limit = (*Ticks) + 4;        /* set time for next null handling */
  1336.         }
  1337.  
  1338.                         /* set sw_bgrnd to 2 if next GNE call will suspend us */
  1339.     if (sw_bgrnd == 1) sw_bgrnd = 2;
  1340.     if (background)
  1341.          rc = WaitNextEvent(everyEvent, &myEvent, 4L, 0L);
  1342.     else rc = GetNextEvent(everyEvent, &myEvent);
  1343.     myStask();            /* needed for FTP in MultiFinder background */
  1344.     if ((rc == 0) && usenull)        /* FALSE from GNE */
  1345.         switch(myEvent.what) {
  1346.             case nullEvent:
  1347.                     if (myWindow != 0) {
  1348.                         if (clklimit < (*Ticks)) {        /* clock updating */
  1349.                             clklimit = (*Ticks) + 600;
  1350.                             newstat();
  1351.                             }
  1352.                         if (!mf_bgrnd) {
  1353.                             /* handle cursor setting */
  1354.                             if (FrontWindow() == myWindow) {
  1355.                                 if (((WindowPeek)myWindow)->visible) {
  1356.                                     GetPort(&gp);
  1357.                                     SetPort(myWindow);
  1358.                                     GetMouse(&pt);
  1359.                                     SetPort(gp);
  1360.                                     i = (PtInRgn(&pt, myWindow->visRgn) == 0);
  1361.                                     if (!i) i = (PtInRect(&pt, &gr_rect) != 0);
  1362.                                     if (dfltcurs != i) {
  1363.                                         if (i) SetCursor(&qd.arrow);
  1364.                                         else SetCursor(*grafcursor);
  1365.                                         dfltcurs = i;
  1366.                                         }
  1367.                                     }
  1368.                                 else {
  1369.                                     arrowcursor();
  1370.                                     }
  1371.                                 }
  1372.                             /* check for color updating */
  1373.                             if (colormac) {
  1374.                                 chkpx();
  1375.                                 if (newCTab()) {
  1376.                                     ActivatePalette(myWindow);
  1377.                                     if (updCTab()) {
  1378.                                         newbackcolor();
  1379.                                         invldscr();
  1380.                                         newstat();
  1381.                                         justGrowIcon(0);
  1382.                                         }
  1383.                                     }
  1384.                                 }
  1385.                             }
  1386.                         }
  1387.                     if (!mf_bgrnd) {
  1388.                         myStask();
  1389.                         SystemTask();            /* run DAs, etc. */
  1390.                         }
  1391.                     if (ppcavail) {            /* check if allocations needed */
  1392.                         addparamblocks();
  1393.                         addclientrecs();
  1394.                         adddatablocks();
  1395.                         }
  1396.                     apinewmsg();            /* check for API event */
  1397.                     break;
  1398.             default:
  1399.                     return;
  1400.             }
  1401.     else if (rc != 0) switch(myEvent.what) {        /* true from GNE */
  1402.         case mouseDown:
  1403.             code = FindWindow(&myEvent.where, &whichWindow);
  1404.             switch (code) {
  1405.             case inMenuBar:
  1406.                 menu_upd();
  1407.                 docommand(MenuSelect(&myEvent.where),
  1408.                           (myEvent.modifiers & shiftKey) != 0);
  1409.                 break;
  1410.             case inSysWindow:
  1411.                 SystemClick(&myEvent, whichWindow);
  1412.                 break;
  1413.             case inDrag:
  1414.                 if (whichWindow == FrontWindow()) {
  1415.                     DragWindow(whichWindow, &myEvent.where,
  1416.                                 &dragRect);
  1417.                     if ((whichWindow == myWindow) && (myWindow != 0)) {
  1418.                         rc = alignbitmaps();
  1419.                         if (rc == 0) {
  1420.                             invldscr();
  1421.                             newstat();
  1422.                             }
  1423.                         }
  1424.                     }
  1425.                 else {
  1426.                     SelectWindow(whichWindow);
  1427.                     }
  1428.                 break;
  1429.             case inGoAway:
  1430.                 if (xdlg && (whichWindow == xdlgptr)) {
  1431.                     if (TrackGoAway(whichWindow, &myEvent.where))
  1432.                         kabort = 1;
  1433.                     break;
  1434.                     }
  1435.                 if ((whichWindow == myWindow) && (myWindow != 0))
  1436.                     if (TrackGoAway(whichWindow,&myEvent.where))
  1437.                         if (wants_to_quit()) {
  1438.                             if (serflg) {
  1439.                                 if (connflg) {
  1440.                                     done = 1;
  1441.                                     }
  1442.                                 else {
  1443.                                     closeresponse(closeUser);
  1444.                                     if (logon) serlgout(0xe3);
  1445.                                     else serlgout(0xe7);
  1446.                                     }
  1447.                                 }
  1448.                             else {
  1449.                                 closeresponse(closeUser);
  1450.                                 if (tcpflg) {
  1451.                                     tcplgout();
  1452.                                     }
  1453.                                 else {
  1454.                                     netlgout();
  1455.                                     }
  1456.                                 }
  1457.                             }
  1458.                 break;
  1459.             case inGrow:
  1460.                 if (whichWindow == FrontWindow()) {
  1461.                     GetPort(&gp);
  1462.                     SetPort(whichWindow);
  1463.                     if ((whichWindow == myWindow) && (myWindow != 0)) {
  1464.                         SetClip(cliprgn);
  1465.                         }
  1466.                     l = GrowWindow(whichWindow, &myEvent.where,
  1467.                                 &sizeRect);
  1468.                     h = l >> 16;
  1469.                     w = l & 0x0000ffffL;
  1470.                     SizeWindow(whichWindow, w, h, true);
  1471.                     if ((whichWindow == myWindow) && (myWindow != 0)) {
  1472.                         InvalRect(&gr_rect);
  1473.                         InitClip();
  1474.                         InvalRect(&gr_rect);
  1475.                         }
  1476.                     if (xdlg && (whichWindow == xdlgptr)) {
  1477.                         EraseRect(&(whichWindow->port.portRect));
  1478.                         InvalRect(&(whichWindow->port.portRect));
  1479.                         }
  1480.                     SetPort(gp);
  1481.                     }
  1482.                 break;
  1483.             case inContent:
  1484.                 if (whichWindow != FrontWindow()) {
  1485.                     SelectWindow(whichWindow);
  1486.                     break;
  1487.                     }
  1488.                 if ((whichWindow == myWindow) && (myWindow != 0)) {
  1489.                     downtime = myEvent.when;
  1490.                     shiftflag = (myEvent.modifiers & shiftKey) != 0;
  1491.                     optionflag = (myEvent.modifiers & optionKey) != 0;
  1492.                     commandflag = (myEvent.modifiers & cmdKey) != 0;
  1493.                     GetPort(&gp);
  1494.                     SetPort(myWindow);
  1495.                     GlobalToLocal(&myEvent.where);
  1496.                     
  1497.                     /* calculate location for cursor movement (moveloc) */
  1498.                     x = (myEvent.where.h-2+htxtstrt)/htxtsize;
  1499.                     y = myEvent.where.v/vtxtsize;
  1500.                     if (x < 0) x = 0;
  1501.                     if (x > scrhoff) x = scrhoff;
  1502.                     if (y < 0) y = 0;
  1503.                     if (y > scrvoff) y = scrvoff;
  1504.                     moveloc = (y*scrhsize) + x;
  1505.  
  1506.                     /* check if mouse down is close enough in time and     */
  1507.                     /* location to be a valid double click                 */
  1508.                     doubleflag = ((downtime - uptime) <= (*DoubleTime)) &&
  1509.                                  (moveloc == uploc);
  1510.                     uptime = 0;
  1511.                                 
  1512.                     /* calculate location for selection (downloc) */
  1513.                     x = (myEvent.where.h-2+htxtstrt)/htxtsize;
  1514.                     y = myEvent.where.v/vtxtsize;
  1515.                     if (x < 0) x = 0;
  1516.                     if (x > scrhoff) {
  1517.                         if (optionflag) x = scrhoff;
  1518.                         else x = scrhsize;
  1519.                         }
  1520.                     if (y < 0) y = 0;
  1521.                     if (y > scrvoff) {
  1522.                         if (optionflag) downloc = (scrvoff*scrhsize) + x;
  1523.                         else downloc = maxcnt;
  1524.                         }
  1525.                     else downloc = (y*scrhsize) + x;
  1526.                     
  1527.                     newloc = downloc;
  1528.                     selflag = 0;
  1529.                     downtime = *Ticks;
  1530.                     while (StillDown()) {
  1531.                         GetMouse(&pt);
  1532.                         x = (pt.h-2+htxtstrt)/htxtsize;
  1533.                         y = pt.v/vtxtsize;
  1534.                         if (x < 0) x = 0;
  1535.                         if (x > scrhoff) {
  1536.                             if (optionflag) x = scrhoff;
  1537.                             else x = scrhsize;
  1538.                             }
  1539.                         if (y < 0) y = 0;
  1540.                         if (y > scrvoff) {
  1541.                             if (optionflag) newloc = (scrvoff*scrhsize) + x;
  1542.                             else newloc = maxcnt;
  1543.                             }
  1544.                         else newloc = (y*scrhsize) + x;
  1545.                         if ((selflag == 0) && (newloc != downloc)) { /* sel init */
  1546.                             if (optionflag == 0) {
  1547.                                 if (shiftflag) {
  1548.                                     checksel();
  1549.                                     if (textsel) addsel(&downloc); /* reset downloc */
  1550.                                     }
  1551.                                 arrowcursor();
  1552.                                 }
  1553.                             selflag = 1;
  1554.                             mousesel(0, downloc, doubleflag);
  1555.                             }
  1556.                         if (selflag) {
  1557.                             if (optionflag) mousesel(1, newloc, doubleflag);    
  1558.                             else mousesel(2, newloc, doubleflag);
  1559.                             }
  1560.                         if (tcpflg) myStask();
  1561.                         }
  1562.                     downtime = (*Ticks) - downtime;
  1563.                     SetPort(gp);
  1564.                     if (selflag) mousesel(3, 0, doubleflag);    /* termination */
  1565.                     if (selflag &&         /* don't use singe position selection */
  1566.                         ((newloc - downloc > 1) || 
  1567.                          (newloc - downloc < -1) ||
  1568.                          (downtime > 60) ||
  1569.                          doubleflag )) {
  1570.                         if (newloc != downloc) {
  1571.                             if (optionflag) {
  1572.                                 if (!shiftflag) resetsel();
  1573.                                 setrectsel(newloc, downloc);
  1574.                                 if (doubleflag) addfieldsel();
  1575.                                 }
  1576.                             else {
  1577.                                 if (commandflag == 0) resetsel();
  1578.                                 if (doubleflag) wordadj(&downloc, &newloc, 1);
  1579.                                 settextsel(newloc, downloc, commandflag);
  1580.                                 }
  1581.                             }
  1582.                         if (serflg && connflg) break;
  1583.                         if (tcpflg && (!logon)) break;
  1584.                         if (doubleflag) {
  1585.                             curadr = oldloc;
  1586.                             newcur();
  1587.                             }
  1588.                         break;
  1589.                         }
  1590.                     if ((atrbuff[downloc] & 0x0020) && (!shiftflag)
  1591.                         && (!doubleflag)) {
  1592.                         resetsel();
  1593.                         break;
  1594.                         }
  1595.                     if (serflg && connflg) break;
  1596.                     if (tcpflg && (!logon)) break;
  1597.                     oldloc = curadr;
  1598.                     curadr = moveloc;
  1599.                     newcur();
  1600.                     if (doubleflag) {
  1601.                         if (kblock || (vmxbgn && (!vmxsub))) beep();
  1602.                         else clickattn(cs.mousepf);
  1603.                         }
  1604.                     }
  1605.                 break;
  1606.  
  1607.             case inZoomIn:
  1608.             case inZoomOut:
  1609.                 if (TrackBox(whichWindow, &myEvent.where, code))
  1610.                     dozoom(whichWindow, code);
  1611.                 break;
  1612.  
  1613.             default:
  1614.                 break;
  1615.             }
  1616.             break;
  1617.  
  1618.         case mouseUp:
  1619.             if (FindWindow(&myEvent.where, &whichWindow) !=
  1620.                 inContent) break;
  1621.             if (myWindow == 0) break;
  1622.             if (whichWindow != myWindow) break;
  1623.             if (myWindow != FrontWindow()) break;
  1624.             uptime = myEvent.when;
  1625.             GetPort(&gp);
  1626.             SetPort(myWindow);
  1627.             GlobalToLocal(&myEvent.where);
  1628.             SetPort(gp);
  1629.             x = (myEvent.where.h-2+htxtstrt)/htxtsize;
  1630.             y = myEvent.where.v/vtxtsize;
  1631.             if (x < 0) x = 0;
  1632.             if (x > scrhoff) x = scrhoff;
  1633.             if (y < 0) y = 0;
  1634.             if (y > scrvoff) y = scrvoff;
  1635.             uploc = (y*scrhsize) + x;
  1636.             break;
  1637.  
  1638.         case keyDown:
  1639.                                         /* check for special user */
  1640.             if ((myEvent.modifiers & 0x0f00) == 0x0f00) {
  1641.                 if (((myEvent.message & 0x7f00) >> 8) == 0x24) {
  1642.                     specuser ^= 1;
  1643.                     break;
  1644.                     }
  1645.                 }
  1646.         case autoKey:
  1647.             if (apiopen) {
  1648.                 if (apiopenreq.hide) {
  1649.                     apiopenreq.hide = 0;    /* to allow beep to work */
  1650.                     beep();
  1651.                     apiopenreq.hide = 1;
  1652.                     }
  1653.                 }
  1654.             asciicode = 0xff;
  1655.             if ((connflg && serflg) ||
  1656.                 (tcpflg && (pend_conn == 3))) {
  1657.                             /* line mode connection */
  1658.                 i = myEvent.message & 0x7f;
  1659.                 if (i == 0x60) i = 0x1b;
  1660.                 if (myEvent.modifiers & cmdKey) {
  1661.                     if (i == 0x1b) i = 0x60;
  1662.                     else {
  1663.                         if (i == 0x08) i = 0x7f;
  1664.                         else i &= 0x1f;
  1665.                         }
  1666.                     }
  1667.                 c = i;
  1668.                 if (serflg) {
  1669.                     ObscureCursor();
  1670.                     if (c == 0x12) {
  1671.                         serverflags = 0x01;
  1672.                         srvswitch();
  1673.                         }
  1674.                     else {
  1675.                         if (servermode) {
  1676.                             putsrv(&c, 1, 1);
  1677.                             }
  1678.                         else {
  1679.                             mout(c);
  1680.                             }
  1681.                         }
  1682.                     break;
  1683.                     }
  1684.                         /* for tcp, echo unless telnet host is doing it */
  1685.                 if (servermode) {
  1686.                     putsrv(&c, 1, 1);
  1687.                     break;
  1688.                     }
  1689.                 if (!hisopts[TELOPT_ECHO])
  1690.                     putscr(&c, 1, 0);
  1691.                 asciicode = i;
  1692.                 }
  1693.             i = (myEvent.message & 0x7f00) >> 8; /* key code */
  1694.             
  1695.                                 /* check special serial mode control characters */
  1696.             if (serflg && (myEvent.modifiers & cmdKey)) {
  1697.                 if (i == 6) {
  1698.                     vmkio(255, 0);    /* cmd-Z */
  1699.                     break;
  1700.                     }
  1701.                 }
  1702.             
  1703.                                     /* apply modifiers for keycode test */
  1704.             if ((myEvent.modifiers & (cmdKey+shiftKey)) ==
  1705.                 (cmdKey+shiftKey)) i += 384;
  1706.             else if (myEvent.modifiers & cmdKey) i += 256;
  1707.             else if (myEvent.modifiers & optionKey) i += 512;
  1708.             else if (myEvent.modifiers & shiftKey) i += 128;
  1709.                                     /* get array entry */
  1710.             k = (*kb_handle)[i];
  1711.                                     /* if no keycode entry, try ASCII code */
  1712.             if (k == 0) {
  1713.                 i = myEvent.message & 0xff;            /* ASCII code */
  1714.                 if ((myEvent.modifiers & (cmdKey+shiftKey)) ==
  1715.                     (cmdKey+shiftKey)) i += 768;
  1716.                 else if (myEvent.modifiers & cmdKey) i += 512;
  1717.                 else if (myEvent.modifiers & optionKey) i += 1024;
  1718.                 else if (myEvent.modifiers & shiftKey) i += 256;
  1719.                 i += 640;            /* skip over keycode tables */
  1720.                                     /* get array entry */
  1721.                 k = (*kb_handle)[i];
  1722.                 }
  1723.                 
  1724.                                     /* if no keycode, check for menu equivalent */
  1725.             if (k == 0) {
  1726.                 if ((myEvent.modifiers & cmdKey) && (myEvent.what == keyDown)) {
  1727.                     menu_upd();
  1728.                     docommand(MenuKey(myEvent.message & 0xff),
  1729.                           (myEvent.modifiers & shiftKey) != 0);
  1730.                     }
  1731.                 break;
  1732.                 }
  1733.             k -= 1;
  1734.             if (myEvent.what == autoKey)
  1735.                 if ((kbtyp[k] & 0x0f) == 2) break;
  1736.             
  1737.             /* check for overriding hex mapping */
  1738.             if (k == 254) {
  1739.                 /* no typeahead for special hex chars */
  1740.                 if (kbqsize > 0) {
  1741.                     beep();
  1742.                     break;
  1743.                     }
  1744.                 s = GetHandleSize(kb_handle);
  1745.                 if (s > 1920) {
  1746.                     hexcount = (s - 1920)/4;
  1747.                     hm = (hexmap *)((*kb_handle) + 1920);
  1748.                     kbstd[k] = 0;
  1749.                     for (j=0; j < hexcount; j++) {
  1750.                         if (hm->offset == i) {
  1751.                             kbstd[k] = hm->stdchar;
  1752.                             kbapl[k] = hm->aplchar;
  1753.                             break;
  1754.                             }
  1755.                         hm++;
  1756.                         }
  1757.                     if (kbstd[k] == 0) break;
  1758.                     }
  1759.                 else break;
  1760.                 }
  1761.             
  1762.             ObscureCursor();
  1763.             h = (myEvent.modifiers & alphaLock) != 0;
  1764.             if (serflg) vmkio(k, h);
  1765.             else if (tcpflg) tcpin(asciicode, k, h);
  1766.             else netin(k, h);
  1767.             break;
  1768.  
  1769.         case activateEvt:
  1770.             dfltcurs = 2;            /* force cursor to be set */
  1771.             if (myEvent.modifiers & activeFlag) {    /* activate event */
  1772.                 if (da_menu != 0) {
  1773.                     da_menu = 0;
  1774.                     SetItem(myMenus[1], 19, "Quit");
  1775.                     }
  1776.                 }
  1777.             else {                                    /* deactivate event */
  1778.                 if (da_menu == 0) {
  1779.                     da_menu = 1;
  1780.                     SetItem(myMenus[1], 19, "Close");
  1781.                     }
  1782.                 if (((struct GrafPort *)myEvent.message == myWindow)
  1783.                      && (myWindow != 0)) {
  1784.                         arrowcursor();
  1785.                         }
  1786.                 }
  1787.             appl_menu();
  1788.             if (((struct GrafPort *)myEvent.message == myWindow) &&
  1789.                 (myWindow != 0)) {
  1790.                 if (myEvent.modifiers & activeFlag) {    /* activate event */
  1791.                     if (colormac) {
  1792.                         updCTab();
  1793.                         newbackcolor();
  1794.                         invldscr();
  1795.                         cs.stat_time += 8;
  1796.                         newstat();
  1797.                         chkpx();
  1798.                         }
  1799.                     }
  1800.                 justGrowIcon(0);        /* activate or deactivate */
  1801.                 }
  1802.             else if (((struct GrafPort *)myEvent.message == xdlgptr)
  1803.                 && xdlg) xfGrowIcon();
  1804.             break;
  1805.  
  1806.         case updateEvt:
  1807.             updevent(myEvent.message);
  1808.             break;
  1809.  
  1810.         case app4Evt:        /* probably switcher */
  1811.             if ((myEvent.message & 0xff000000) != 0x01000000)
  1812.                 break;    /* not switcher event */
  1813.             else if (myEvent.message & 0x00000001) sw_resume(myEvent.message);
  1814.                     else sw_suspend(myEvent.message);
  1815.             break;
  1816.  
  1817.         case diskEvt:    /* if mount failed, put up disk init dialog */
  1818.             if ((myEvent.message & 0xffff0000) != 0) {
  1819.                 dipoint.h = kDILeft;
  1820.                 dipoint.v = kDITop;
  1821.                 DIBadMount(&dipoint, myEvent.message);
  1822.                 }
  1823.             break;
  1824.  
  1825.         default:    break;
  1826.         }
  1827. }
  1828.  
  1829. dozoom(wp, code)
  1830. struct WindowRecord * wp;
  1831. short code;
  1832. {
  1833. GrafPtr gp;
  1834. WStateData * wsptr;
  1835. OSErr rc;
  1836.  
  1837.                         /* be sure this window can zoom */
  1838. if (((WindowPeek)wp)->dataHandle == 0) return;
  1839.  
  1840. GetPort(&gp);
  1841. SetPort(wp);
  1842. if ((wp == myWindow) && (myWindow != 0)) SetClip(cliprgn);
  1843. EraseRect(&(wp->port.portRect));
  1844. ZoomWindow(wp, code, false);
  1845. if ((wp == myWindow) && (myWindow != 0)) {
  1846.     InitClip();
  1847.     InvalRect(&gr_rect);
  1848.     rc = alignbitmaps();
  1849.     if (rc == 0) {
  1850.         invldscr();
  1851.         newstat();
  1852.         }
  1853.     }
  1854. SetPort(gp);
  1855. }
  1856.  
  1857. short zoomstate()
  1858. {
  1859. struct Point topleft, bottomright;
  1860. Rect r;
  1861. WStateData * wsptr;
  1862. GrafPtr gp;
  1863.  
  1864. if (myWindow == 0) return(0);    /* return if no window */
  1865.                                 /* be sure my window can zoom */
  1866. if (((WindowPeek)myWindow)->dataHandle == 0) return(0);
  1867.  
  1868.                                 /* convert portRect to global coordinates */
  1869. GetGlobalRect(myWindow, &r);
  1870.                                 /* check for standard vs. user state */
  1871. wsptr = (struct WStateData *)(*(((WindowPeek)myWindow)->dataHandle));
  1872. if ((wsptr->stdState) == r) return(inZoomIn);    /* return code */
  1873. else return(inZoomOut);
  1874. }
  1875.  
  1876. chkpx() {                /* handle user changing pixel bit depth */
  1877. GDHandle currGD;
  1878. PixMapHandle currPM, myPM, newPM;
  1879. GrafPort gp, newport;
  1880. char * newptr;
  1881. RGBColor rgbtemp;
  1882. Rect r;
  1883.  
  1884. if (!colormac) return;
  1885. GetGlobalRect(myWindow, &r);
  1886. currGD = GetMaxDevice(&r);
  1887. currPM = (*currGD)->gdPMap;
  1888. if (pxsize == (*currPM)->pixelSize) return;
  1889. newdepth();
  1890. }
  1891.  
  1892. fixcolors(p)        /* fixcolors is called to handle a redefinition of        */
  1893. PaletteHandle p;    /* one of the "usr" colors.  It updates the specified    */
  1894.                     /* palette and associated window.                        */
  1895. {
  1896. short i, usage;
  1897. RGBColor rgbtemp;
  1898.  
  1899. if (cs.exactcolor) {
  1900.     SetEntryColor(p, RGBblack, &cs.usrblack);
  1901.     SetEntryColor(p, RGBwhite, &cs.usrwhite);
  1902.     SetEntryColor(p, RGBback, &cs.usrback);
  1903.     SetEntryColor(p, RGBgreen, &cs.usrgreen);
  1904.     SetEntryColor(p, RGBred, &cs.usrred);
  1905.     SetEntryColor(p, RGBblue, &cs.usrblue);
  1906.     SetEntryColor(p, RGBpink, &cs.usrpink);
  1907.     SetEntryColor(p, RGByellow, &cs.usryellow);
  1908.     SetEntryColor(p, RGBturquoise, &cs.usrturquoise);
  1909.     SetEntryColor(p, RGBstat, &cs.usrstat);
  1910.     }
  1911. else {
  1912.     mapcolor(&cs.usrblack, &rgbtemp);
  1913.     SetEntryColor(p, RGBblack, &rgbtemp);
  1914.     SetEntryColor(p, RGBwhite, &cs.usrwhite);
  1915.     SetEntryColor(p, RGBback, &cs.usrback);
  1916.     mapcolor(&cs.usrgreen, &rgbtemp);
  1917.     SetEntryColor(p, RGBgreen, &rgbtemp);
  1918.     mapcolor(&cs.usrred, &rgbtemp);
  1919.     SetEntryColor(p, RGBred, &rgbtemp);
  1920.     mapcolor(&cs.usrblue, &rgbtemp);
  1921.     SetEntryColor(p, RGBblue, &rgbtemp);
  1922.     mapcolor(&cs.usrpink, &rgbtemp);
  1923.     SetEntryColor(p, RGBpink, &rgbtemp);
  1924.     mapcolor(&cs.usryellow, &rgbtemp);
  1925.     SetEntryColor(p, RGByellow, &rgbtemp);
  1926.     mapcolor(&cs.usrturquoise, &rgbtemp);
  1927.     SetEntryColor(p, RGBturquoise, &rgbtemp);
  1928.     mapcolor(&cs.usrstat, &rgbtemp);
  1929.     SetEntryColor(p, RGBstat, &rgbtemp);
  1930.     }
  1931.  
  1932. if (cs.exactcolor) usage = pmTolerant;
  1933.            else usage = pmCourteous;
  1934. for (i=1; i < 10; i++)
  1935.     SetEntryUsage(p, i, usage, 0);
  1936. }
  1937.  
  1938. mapcolor(in, out)
  1939. RGBColor * in, * out;
  1940. {
  1941. long l;
  1942. short i;
  1943. RGBColor csave;
  1944.  
  1945. if (textmap) setgdev();
  1946. l = Color2Index(in);
  1947. i = l &0x0000ffff;
  1948. csave = *in;
  1949. if (i == 0) {
  1950.     csave = *in;
  1951.     InvertColor(&csave);
  1952.     *out = csave;
  1953.     }
  1954. else *out = *in;
  1955. if (textmap) resetgdev();
  1956. }
  1957.  
  1958. actualcolor(in, out)  /* convert color to actual color displayed */
  1959. RGBColor * in, *out;
  1960. {
  1961. if (textmap) setgdev();
  1962. Index2Color(Color2Index(in), out);
  1963. if (textmap) resetgdev();
  1964. }
  1965.  
  1966. updevent(msgptr)
  1967. GrafPtr msgptr;
  1968. {
  1969. short i, txtmode;
  1970. long t;
  1971. GrafPtr gp;
  1972. BitMap * srcbits;
  1973. char statflg;
  1974. PixMapHandle currPM;
  1975.  
  1976. statflg = 0;
  1977. GetPort(&gp);
  1978. SetPort(msgptr);
  1979. if ((msgptr == myWindow) && (myWindow != 0)) {
  1980.     SetClip(cliprgn);
  1981.     }
  1982. BeginUpdate(msgptr);
  1983. if ((msgptr == myWindow) && (myWindow != 0)) {
  1984.     if (WritePtr != myWindow) {
  1985.         if (RectInRgn(&textRect, myWindow->visRgn) && needwrite) {
  1986.             SetPort(WritePtr);
  1987.             setgdev();
  1988.             writescr(0);
  1989.             resetgdev();
  1990.             SetPort(myWindow);
  1991.             needwrite = 0;
  1992.             if (wr_active) statflg = 1;
  1993.             }
  1994.         if (colormac) {
  1995.             RGBForeColor(&realblack);
  1996.             RGBBackColor(&realwhite);
  1997.             }
  1998.         if (drawpict && (PictPtr != 0)) {
  1999.             if (colormac)
  2000.                 srcbits = (BitMap *)(*(PixMapHandle)PictPort.portBits.baseAddr);
  2001.             else
  2002.                 srcbits = &PictPort.portBits;
  2003.             CopyBits(srcbits, &(myWindow->portBits),
  2004.                             &pictRect, &textRect, srcCopy, 0L);
  2005.             }
  2006.         if (colormac)
  2007.             srcbits = (BitMap *)(*(PixMapHandle)WritePort.portBits.baseAddr);
  2008.         else
  2009.             srcbits = &WritePort.portBits;
  2010.         if (drawpict) {
  2011.             if (colormac) {
  2012.                 currPM = (*bitmap_gdev)->gdPMap;
  2013.                 if (((*currPM)->pixelSize) > 1) {
  2014.                     if (cs.invertbw) txtmode = adMin;
  2015.                     else txtmode = adMax;
  2016.                     }
  2017.                 else {
  2018.                     if (cs.invertbw) txtmode = srcOr;
  2019.                     else txtmode = notSrcBic;
  2020.                     }
  2021.                 }
  2022.             else {
  2023.                 txtmode = srcOr;
  2024.                 }
  2025.             CopyBits(srcbits, &(myWindow->portBits),
  2026.                      &textRect, &textRect, txtmode, 0L);
  2027.             CopyBits(srcbits, &(myWindow->portBits),
  2028.                      &statRect, &statRect, srcCopy, 0L);
  2029.             }
  2030.         else CopyBits(srcbits, &(myWindow->portBits),
  2031.                  &scrnRect, &scrnRect, srcCopy, 0L);
  2032.         drawcurs(0);        /* draw cursor, no restore */
  2033.         if (RectInRgn(&gr_rect, myWindow->visRgn)) justGrowIcon(1);
  2034.         }
  2035.     else {
  2036.         if (RectInRgn(&textRect, myWindow->visRgn)) {
  2037.             writescr(0);
  2038.             needwrite = 0;
  2039.             if (wr_active) statflg = 1;
  2040.             }
  2041.         if (RectInRgn(&statRect, myWindow->visRgn)) {
  2042.             statline();
  2043.             }
  2044.         if (RectInRgn(&gr_rect, myWindow->visRgn)) justGrowIcon(1);
  2045.         }
  2046.     }
  2047. else if ((xdlg == 1) && (msgptr == xdlgptr)) {    
  2048.         DrawDialog(xdlgptr);
  2049.         xfGrowIcon();
  2050.         }
  2051. EndUpdate(msgptr);
  2052. if ((msgptr == myWindow) && (myWindow != 0)) SetClip(destrgn);
  2053. SetPort(gp);
  2054. if (statflg) {
  2055.     wr_active = 0;
  2056.     newstat();
  2057.     }
  2058. if (showstg) {
  2059.     showstg = 0;
  2060.     stginfo();
  2061.     }
  2062. }
  2063.  
  2064. mkPix(gptr, mptr, b_rect, mustalloc, gdev)
  2065. GrafPtr gptr;
  2066. char ** mptr;
  2067. Rect * b_rect;
  2068. char mustalloc;
  2069. GDHandle gdev;
  2070. {
  2071.     GDHandle saveGD;
  2072.     Size mmapsize;
  2073.     Ptr temp;
  2074.     PixMapPtr pixptr;
  2075.     PixMapHandle devPM;
  2076.     CTabHandle myCTabHandle;
  2077.     OSErr memerr;
  2078.  
  2079.     saveGD = GetGDevice();
  2080.     SetGDevice(gdev);
  2081.     OpenCPort(gptr);
  2082.     pixptr = *(PixMapHandle)(gptr->portBits.baseAddr);
  2083.     pixptr->bounds = *b_rect;
  2084.     PortSize(pixptr->bounds.right, pixptr->bounds.bottom);
  2085.     SetRectRgn(gptr->visRgn, 0, 0, pixptr->bounds.right,
  2086.                 pixptr->bounds.bottom);
  2087.     devPM = (*gdev)->gdPMap;
  2088.     pixptr->rowBytes = ((((hpixsize * (*devPM)->pixelSize) + 31) >> 5) + 1) << 2;
  2089.     mmapsize = pixptr->bounds.bottom - pixptr->bounds.top;
  2090.     mmapsize = mmapsize * pixptr->rowBytes + 4;
  2091.     pictsize = mmapsize;
  2092.     *mptr = myNewPtr(mmapsize);
  2093.     temp = *mptr;
  2094.     while (((Size)temp%4) != 0) temp++;    /* align on long word */
  2095.     pixptr = *(PixMapHandle)(gptr->portBits.baseAddr);
  2096.     pixptr->baseAddr = temp;
  2097.     if (pixptr->baseAddr == 0L) {        /* no bitmap */ 
  2098.         if (mustalloc) {
  2099.             SetGDevice(saveGD);
  2100.             stgalert("color bitmap", "NewPtr", mmapsize);
  2101.             ExitToShell();
  2102.             }
  2103.         else {
  2104.             SetGDevice(saveGD);
  2105.             CloseCPort(gptr);
  2106.             return;
  2107.             }
  2108.         }
  2109.     pixptr->rowBytes += 0x8000;
  2110.  
  2111.     /* set-up color table for our map */
  2112.     devPM = (*gdev)->gdPMap;
  2113.     myCTabHandle = (*devPM)->pmTable;
  2114.     memerr = HandToHand(&myCTabHandle);
  2115.     if (memerr != 0)
  2116.         if (mustalloc) {
  2117.             SetGDevice(saveGD);
  2118.             stgalert("color table", "NewPtr", mmapsize);
  2119.             ExitToShell();
  2120.             }
  2121.         else {
  2122.             SetGDevice(saveGD);
  2123.             DisposPtr(*mptr);
  2124.             *mptr = 0;
  2125.             CloseCPort(gptr);
  2126.             return;
  2127.             }
  2128.     pixptr = *(PixMapHandle)(gptr->portBits.baseAddr);
  2129.     pixptr->pmTable = myCTabHandle;
  2130.  
  2131.     /* miscellaneous stuff */
  2132.     
  2133.     ClipRect(&(gptr->portRect));
  2134.     EraseRect(&(gptr->portRect));
  2135.     SetOrigin(0, 0);
  2136.     TextFont(stdfont);
  2137.     TextSize(cur_ptsize);
  2138.     SetGDevice(saveGD);
  2139. }
  2140.  
  2141. Ptr myNewPtr(s)
  2142. Size s;
  2143. {
  2144. Ptr result;
  2145. long l, reserve;
  2146. long tcpgetrsrv();
  2147.  
  2148. result = NewPtr(s);
  2149. if (result == 0) return(result);
  2150.  
  2151. /* check there is still enough free storage for normal operation */
  2152. MaxApplZone();
  2153. l = FreeMem();
  2154. reserve = 32768;        /* need at least 32K in any case */
  2155. if (tcpflg) {                /* adjust for TCP/IP */
  2156.     reserve += tcpgetrsrv(0);    /* was tcpgetrsrv(initflg) */
  2157.     }
  2158. else {                        /* adjust for serial and appletalk */
  2159. /*    if (initflg) reserve += 40960;    */
  2160.     }
  2161. if (l < reserve) {
  2162.     DisposPtr(result);
  2163.     result = 0;
  2164.     }
  2165. return(result);
  2166. }
  2167.  
  2168. int updCTab()                /* check for new color table */
  2169. {
  2170. GDHandle currGD;
  2171. PixMapHandle currPM, myPM;
  2172. CTabHandle currcth, mycth;
  2173. OSErr memerr;
  2174. Rect r;
  2175.  
  2176. if (!textmap) return(0);
  2177.  
  2178. GetGlobalRect(myWindow, &r);
  2179. currGD = GetMaxDevice(&r);
  2180. currPM = (*currGD)->gdPMap;
  2181. currcth = (*currPM)->pmTable;
  2182.  
  2183. myPM = (PixMapHandle)(WritePtr->portBits.baseAddr);
  2184. mycth = (*myPM)->pmTable;
  2185.  
  2186. /* return if color table hasn't changed */
  2187. if ((*currcth)->ctSeed == (*mycth)->ctSeed) return(0);
  2188.  
  2189. /* return if pixel depth has changed */
  2190. if ((*myPM)->pixelSize != (*currPM)->pixelSize) return(0);
  2191.  
  2192. /* make my color table match the new one */
  2193. DisposHandle(mycth);
  2194.  
  2195. currGD = GetMaxDevice(&r);
  2196. currPM = (*currGD)->gdPMap;
  2197. currcth = (*currPM)->pmTable;
  2198. myPM = (PixMapHandle)(WritePtr->portBits.baseAddr);
  2199.  
  2200. (*myPM)->pmTable = currcth;
  2201. memerr = HandToHand(&((*myPM)->pmTable));
  2202. if (memerr != 0) {
  2203.     stgalert("text color table", "HandToHand", 0L);
  2204.     ExitToShell();
  2205.     }
  2206.  
  2207. /* repeat for graphics bitmap */
  2208. if (PictPtr == 0) return(1);
  2209. myPM = (PixMapHandle)(PictPtr->portBits.baseAddr);
  2210. mycth = (*myPM)->pmTable;
  2211. /* make my color table match the new one */
  2212. DisposHandle(mycth);
  2213.  
  2214. currGD = GetMaxDevice(&r);
  2215. currPM = (*currGD)->gdPMap;
  2216. currcth = (*currPM)->pmTable;
  2217. myPM = (PixMapHandle)(PictPtr->portBits.baseAddr);
  2218.  
  2219. (*myPM)->pmTable = currcth;
  2220. memerr = HandToHand(&((*myPM)->pmTable));
  2221. if (memerr != 0) {
  2222.     stgalert("graphics color table", "HandToHand", 0L);
  2223.     ExitToShell();
  2224.     }
  2225. return(2);
  2226. }
  2227.  
  2228. int newCTab()                /* check for new color table */
  2229. {
  2230. GDHandle currGD;
  2231. PixMapHandle currPM, myPM;
  2232. CTabHandle currcth, mycth;
  2233. Rect r;
  2234.  
  2235. if (!textmap) return(0);
  2236.  
  2237. GetGlobalRect(myWindow, &r);
  2238. currGD = GetMaxDevice(&r);
  2239. currPM = (*currGD)->gdPMap;
  2240. currcth = (*currPM)->pmTable;
  2241.  
  2242. myPM = (PixMapHandle)(WritePtr->portBits.baseAddr);
  2243. mycth = (*myPM)->pmTable;
  2244.  
  2245. /* return 0 if color table hasn't changed */
  2246. if ((*currcth)->ctSeed == (*mycth)->ctSeed) return(0);
  2247.  
  2248. /* return 0 if pixel depth has changed */
  2249. if ((*myPM)->pixelSize != (*currPM)->pixelSize) return(0);
  2250.  
  2251. /* else return 1 */
  2252. return(1);
  2253. }
  2254.  
  2255. rmPix(gptr, mptr)
  2256. GrafPtr gptr;
  2257. Ptr mptr;
  2258. {
  2259. PixMapPtr pixptr;
  2260.  
  2261.                                     /* dispose copy of color table */
  2262. pixptr = *(PixMapHandle)(gptr->portBits.baseAddr);
  2263. DisposHandle(pixptr->pmTable);
  2264. if (mptr != 0) DisposPtr(mptr);
  2265. pixptr->baseAddr = 0;
  2266. CloseCPort(gptr);
  2267. }
  2268.  
  2269. newinvbw()        /* make updates to handle a new value of invbw */
  2270. {
  2271. if (!colormac) return;
  2272.  
  2273. if (cs.invertbw) {
  2274.     if (curnum > 20846) curnum -= 2;
  2275.     else return;
  2276.     }
  2277. else {
  2278.     if (curnum < 20847) curnum += 2;
  2279.     else return;
  2280.     }
  2281. grafcursor = GetCursor(curnum);
  2282. dfltcurs = 2;        /* force SetCursor call */
  2283. }
  2284.  
  2285. newbackcolor()
  2286. {
  2287. RGBColor rgbtemp;
  2288. GrafPtr gp;
  2289.  
  2290. GetEntryColor(myPalette, RGBback, &rgbtemp);
  2291. GetPort(&gp);
  2292. SetPort(WritePtr);
  2293. if (textmap) setgdev();
  2294. RGBBackColor(&rgbtemp);
  2295. if (PictPtr != 0) {
  2296.     SetPort(PictPtr);
  2297.     RGBBackColor(&rgbtemp);
  2298.     }
  2299. SetPort(gp);
  2300. if (textmap) resetgdev();
  2301. }
  2302.  
  2303. setgdev()
  2304. {
  2305. if (!colormac) return;
  2306. saved_gdev = GetGDevice();
  2307. SetGDevice(bitmap_gdev);
  2308. }
  2309.  
  2310. resetgdev()
  2311. {
  2312. if (!colormac) return;
  2313. SetGDevice(saved_gdev);
  2314. }
  2315.  
  2316. adjfmt(changed, windmax, dfltptsize, altptsize, altrows, altcols)
  2317. char *changed, *windmax;
  2318. short *dfltptsize, *altptsize, *altrows, *altcols;
  2319. /* adjust screen format settings to be valid for the current set of gdevs */
  2320. {
  2321. char altok;
  2322. short altsize, newptsize, newrows, newcols, maxrows, maxcols;
  2323.  
  2324. (*changed) = 0;
  2325.  
  2326. /* set default point size to 9 if 24-by-80 won't fit with 12-point */
  2327. if ((rowmax12 < 24) || (colmax12 < 80)) {
  2328.     if ((*dfltptsize) == 12) {
  2329.         (*dfltptsize) = 9;
  2330.         (*changed) = 1;
  2331.         }
  2332.     }
  2333. /* check alternate screen size is valid */
  2334. if ((*altrows) < 24) {
  2335.     (*altrows) = 24;
  2336.     (*changed) = 1;
  2337.     }
  2338. if ((*altcols) < 80) {
  2339.     (*altcols) = 80;
  2340.     (*changed) = 1;
  2341.     }
  2342.  
  2343. /* check if alternate screen size will fit */
  2344. if ((*altptsize) == 9) {
  2345.     altok = (((*altrows) <= rowmax9) && ((*altcols) <= colmax9));
  2346.     }
  2347. else {
  2348.     altok = (((*altrows) <= rowmax12) && ((*altcols) <= colmax12));
  2349.     }
  2350. /* if not, and 12-point specified, try 9-point */
  2351. if (((*altptsize) == 12) && (!altok)) {
  2352.     altok = (((*altrows) <= rowmax9) && ((*altcols) <= colmax9));
  2353.     if (altok) {
  2354.         (*altptsize) = 9;    
  2355.         (*changed) = 1;
  2356.         }
  2357.     }
  2358. if (altok) {
  2359.     return;
  2360.     }
  2361.     
  2362. /* find the closest standard model that will fit, and use the largest point
  2363.    size for that model */
  2364.  
  2365. altsize = (*altrows) * (*altcols);
  2366. if ((altsize >= 3564) && ((*altcols) > 80)) {
  2367.     newrows = 27;    /* model 5 */
  2368.     newcols = 132;
  2369.     }
  2370. else if (altsize >= 3440) {
  2371.     newrows = 43;    /* model 4 */
  2372.     newcols = 80;
  2373.     }
  2374. else if (altsize >= 2560) {
  2375.     newrows = 32;    /* model 3 */
  2376.     newcols = 80;
  2377.     }
  2378. else {
  2379.     newrows = 24;    /* model 2 */
  2380.     newcols = 80;
  2381.     }
  2382. newptsize = 12;
  2383. maxrows = rowmax12;
  2384. maxcols = colmax12;
  2385. while ((newrows > 24) || (newptsize > 9)) {
  2386.     /* test this model/ptsize */
  2387.     if ((newrows <= maxrows) && (newcols <= maxcols)) break; 
  2388.     /* set next model/ptsize */
  2389.     if (newptsize == 12) {
  2390.         newptsize = 9;
  2391.         maxrows = rowmax9;
  2392.         maxcols = colmax9;
  2393.         }
  2394.     else {
  2395.         newptsize = 12;
  2396.         maxrows = rowmax12;
  2397.         maxcols = colmax12;
  2398.         newcols = 80;
  2399.         if (newrows == 27) newrows = 43;
  2400.         else if (newrows == 43) newrows = 32;
  2401.         else if (newrows == 32) newrows = 24;
  2402.         }
  2403.     }
  2404. (*altptsize) = newptsize;
  2405. (*altrows) = newrows;
  2406. (*altcols) = newcols;
  2407. (*changed) = 1;
  2408. }
  2409.  
  2410. newstdfont(f)
  2411. short f;
  2412. {
  2413. GrafPtr gp;
  2414.  
  2415. stdfont = f;
  2416. fixbracket = cs.std_brack && (!aplmode) && (stdfont != ALAFONT);
  2417. if (myWindow == 0) return;
  2418. GetPort(&gp);
  2419. SetPort(myWindow);
  2420. TextFont(f);
  2421. if (WritePtr != 0) {
  2422.     SetPort(WritePtr);
  2423.     TextFont(f);
  2424.     }
  2425. if (PictPtr != 0) {
  2426.     SetPort(PictPtr);
  2427.     TextFont(f);
  2428.     }
  2429. SetPort(gp);
  2430. }
  2431.  
  2432. updwindpos()
  2433. {
  2434. Point p;
  2435. GrafPtr gp;
  2436.  
  2437. if (myWindow == 0) return;
  2438.  
  2439. p.h = (myWindow->portRect.right + myWindow->portRect.left + 1)/2;
  2440. p.v = (myWindow->portRect.bottom + myWindow->portRect.top - 17)/2;
  2441. GetPort(&gp);
  2442. SetPort(myWindow);
  2443. LocalToGlobal(&p);        /* global current center */
  2444. SetPort(gp);
  2445. cs.windpth = p.h;
  2446. cs.windptv = p.v;
  2447. wposok = 1;
  2448. }
  2449.